package com.cjc.express.utils;


import com.cjc.express.entity.Company;
import com.cjc.express.entity.Price;

import java.util.*;

public class ExpressUtils {

    // @描述：是否是2003的excel，返回true是2003
    public static boolean isExcel2003(String filePath) {
        return filePath.matches("^.+\\.(?i)(xls)$");
    }

    //@描述：是否是2007的excel，返回true是2007
    public static boolean isExcel2007(String filePath) {
        return filePath.matches("^.+\\.(?i)(xlsx)$");
    }

    /**
     * 验证EXCEL文件
     *
     * @param filePath
     * @return
     */
    public static boolean validateExcel(String filePath) {
        if (filePath == null || !(isExcel2003(filePath) || isExcel2007(filePath))) {
            return false;
        }
        return true;
    }

    /**
     * @param str
     * @return false 不是数
     * @创建时间 2018年1月20日
     * @描述 正则表达式，判断一个字符是否为一个数, 是返回true,否则返回false
     * @author hjj
     */
    public static boolean isNumeric(String str) {
        String reg = "^[0-9]*";
        return str.matches(reg);
    }

    /**
     * @param string
     * @return stringnew
     * @创建时间 2018年1月21日
     * @描述 提取字符串中的数字
     * @author dyp
     */
    public static String getNumber(String string) {
        String stringnew = "";
        string.trim();
        if (null != string && string.length() > 0) {
            for (int i = 0; i < string.length(); i++) {
                if (string.charAt(i) >= 48 && string.charAt(i) <= 57) {
                    stringnew += string.charAt(i);
                }
            }
        }
        return stringnew;
    }

    public static String checkExcell(List<Price> prices) {

        String msg = "";

        if (prices.size() == 0 || prices.size() == 1) return msg;

        for (int i = 0; i < prices.size() - 1; i++) {
            Price price1 = prices.get(i);
            for (int j = i + 1; j < prices.size(); j++) {
                Price price2 = prices.get(j);
                if (price1.getCompanyname().equals(price2.getCompanyname()) &&
                        price1.getPriceorigin().equals(price2.getPriceorigin()) &&
                        price1.getPricedest().equals(price2.getPricedest())) {
                    msg += "第" + (i + 2) + "行数据与第" + (j + 2) + "行数据冲突; </br>";
                }
            }
        }
        return msg;
    }

    public static boolean isLegalNumber(String str) {

        //判断接受的字符串是否为数字
        boolean numeric = isNumeric(str);
        if (numeric && str.length() <= 4) return true;
        return false;
    }

    @SuppressWarnings("/rawtypes")
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if ((obj instanceof List)) {
            return ((List) obj).size() == 0;
        }
        if ((obj instanceof String)) {
            return ((String) obj).trim().equals("");
        }
        return false;
    }

    /**
     * @return uuid
     * @创建时间 2018年1月21日
     * @描述 获取uuid
     * @author dyp
     */
    public static String getUuid() {
        return UUID.randomUUID().toString();
    }

    /**
     * 判断字符串是否为空
     *
     * @param judge 字符串
     * @return true 该字符串为空 false 该字符串不为空
     */
    public static boolean JudgeNull(String judge) {
        if (judge == null || judge.length() <= 0) {
            return true;
        }
        return false;
    }

    /**
     * 判断company对象是否合法
     *
     * @param company 快递公司对象
     * @return true 对象不和法 false 对象合法
     */
    public static boolean CheckCompany(Company company) {
        // 判断字段为空
        if (JudgeNull(company.getCompanyname()) || JudgeNull(company.getCompanyid())) {
            return true;
        } else if (company.getCompanyname().length() > 8 || company.getCompanyid().length() > 36) {
            // 判断字段长度
            return true;
        }
        return false;
    }

    /**
     * 获取去重快递公司后的价格表
     * @param pricesList
     * @return
     */
    public static List<Price> getPriceDest(List<Price> pricesList) {
//        List<Price>prices=new ArrayList<>();
//        Set set=new HashSet();
//        for (Price price : prices1) {
//            if (set.add(price.getCompanyname())) {
//                prices.add(price);
//            }
//        }
//        return prices;

        for(int i=1;i<pricesList.size();i++) {
            if (pricesList.get(i).getCompanyname().equals(pricesList.get(i-1).getCompanyname())) {
                pricesList.remove(i);
                i--;
            }
        }
        return pricesList;


    }

    /**
     * 获取去重省份后的价格表
     * @param pricesList
     * @return
     */
    public static List<Price> getPriceCompany(List<Price> pricesList) {
//        List<Price>prices=new ArrayList<>();
//        Set set=new HashSet();
//        for (Price price : prices1) {
//            int index=price.getPricedest().indexOf("/");
//            if (index == -1) {
//                prices.add(price);
//            }else {
//                String province=price.getPricedest().substring(0,index);
//                if (set.add(province)) {
//                    prices.add(price);
//                }
//            }
//        }
//        return prices;

//        for(int i=1;i<pricesList.size();i++) {
//            int index=pricesList.get(i-1).getPricedest().indexOf("/");
//            int index1=pricesList.get(i).getPricedest().indexOf("/");
//            if (index == -1||index1==-1) {
//
//            }else {
//                String province=pricesList.get(i-1).getPricedest().substring(0,index);
//                String province1=pricesList.get(i).getPricedest().substring(0,index1);
//                if (province.equals(province1)) {
//                    pricesList.remove(i);
//                    i--;
//                }
//            }
//        }
//        return pricesList;


        for(int i=1;i<pricesList.size();i++) {
            String dest=pricesList.get(i-1).getPricedest();
            int index=dest.indexOf("/");
            if (index != -1) {
                dest=dest.substring(0,index);
            }
            if(pricesList.get(i).getPricedest().contains(dest)){
                pricesList.remove(i);
                i--;
            }
        }
        return pricesList;
    }



    /**
     * 判断价格对象是否合法
     *
     * @param price 价格对象
     * @return true 对象不和法 false 对象合法
     */
    public static boolean CheckPrice(Price price) {
        // 判断字段是否为空
        if (JudgeNull(price.getCompanyname()) || JudgeNull(price.getPricedest())
                || JudgeNull(price.getPriceinitweight().toString()) || JudgeNull(price.getPriceoverweight().toString())
                || !ExpressUtils.isNumeric(price.getPriceinitweight().toString())
                || !ExpressUtils.isNumeric(price.getPriceoverweight().toString())) {
            return true;
        } else if (price.getCompanyname().length() > 8 || price.getPriceinitweight().toString().length() > 4
                || price.getPriceoverweight().toString().length() > 4
                || price.getPricedest().length() > 20) {
            // 判断字段长度
            return true;
        }
        return false;
    }

    /**
     * @param dest
     * @return
     * @创建时间 2018年1月25日19:34:16
     * @描述 检测收件地地名格式的合法性
     * @author hjj
     */
    public static String processPDestString(String dest) {
        // 省与市的分隔符
        final String separator = "/";
        // 确定斜杠线的位置
        int index1 = dest.indexOf(separator);
        // "市"字的下标
        int indexOfC = dest.indexOf("市");

        // 如果包含直辖市字符，直接返回市名
        if (dest.contains("北京")) return "北京";
        else if (dest.contains("天津")) return "天津";
        else if (dest.contains("上海")) return "上海";
        else if (dest.contains("重庆")) return "重庆";
        else if (dest.contains("香港")) return "香港";
        else if (dest.contains("澳门")) return "澳门";
        else if (dest.contains("台湾")) return "台湾";

        if (dest.contains("省")) {
            // 如果收件地包含"省"字，剪去"省"字
            dest = dest.replace("省", "");
        }

        if (dest.contains("内蒙古自治区")) {
            dest = dest.replace("自治区", "");
        }
        // 如果包含自治区，除内蒙古外，省只取前两个字
        if (dest.contains("自治区")) {
            dest = dest.substring(0, 2).concat(dest.substring(index1));
        }
        // 如果市名（包含“市”字）超过2个字，减去“市”字
        if (dest.contains("市") && (indexOfC - index1) > 2) {
            indexOfC = dest.indexOf("市");
            dest = dest.substring(0, indexOfC);
        }

        return dest;
    }

    /**
     * @param
     * @return
     * @创建时间 2018年1月25日22:19:32
     * @描述 判断字符串是否是中文
     * @author hjj
     */
    public static boolean isChinese(String str) {
        // 将字符串放入char数组里
        char[] charArray = str.toCharArray();
        // 遍历数组
        for (char c : charArray) {
            if (c >= 0x0391 && c <= 0xFFE5 || c == '/') continue;
                // 遇到英文字符返回false
            else return false;
        }
        return true;
    }

    /**
     * @param dest
     * @return
     * @创建时间： 2018年1月25日23:24:13
     * @描述： 判断收件地名称是否符合规则（四川省/成都市、四川/成都、内蒙古自治区/呼和浩特市、）
     */
    public static boolean isLegalDestName(String dest) {

        // 省与市的分隔符
        final String separator = "/";
        // 确定第一根斜杠线的位置，也就是省与市的分割线
        int index1 = dest.indexOf(separator);
        // 第二根斜杠的位置，也就是市与区(县)的分割线
        int index2 = dest.indexOf(separator, index1 + 1);
        // "省"字的下标
        int indexOfP = dest.indexOf("省");
        // "市"字的下标
        int indexOfC = dest.indexOf("市");

        // 直辖市不用斜杠
        if (dest.contains("北京") || dest.contains("天津") || dest.contains("重庆")
                || dest.contains("上海") || dest.contains("香港") || dest.contains("台湾")
                || dest.contains("澳门")) return true;

        // 收件地只能为省/市，如果有县区则非法
        if (index2 != -1) return false;

        // 若省得名字只有一个或者没有按省/市格式，则非法
        if (index1 < 2) return false;

        // 字符串的长度必须超过5个字
        if (dest.length() < (index1 + 3)) return false;

        // 如果省在市的后面，省/市颠覆写--市/省，收件地不合法
        if (indexOfP > indexOfC) return false;

        return true;
    }

}
